/*
 * Copyright 2002-2018 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.test.context.support;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextException;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.GenericTypeResolver;
import org.springframework.core.annotation.AnnotationAwareOrderComparator;
import org.springframework.core.env.PropertySource;
import org.springframework.core.io.ClassPathResource;
import org.springframework.test.context.*;
import org.springframework.test.context.util.TestContextResourceUtils;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.util.ResourceUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

/**
 * Abstract application context loader that provides a basis for all concrete
 * implementations of the {@link ContextLoader} SPI. Provides a
 * <em>Template Method</em> based approach for {@link #processLocations processing}
 * resource locations.
 *
 * <p>As of Spring 3.1, {@code AbstractContextLoader} also provides a basis
 * for all concrete implementations of the {@link SmartContextLoader} SPI. For
 * backwards compatibility with the {@code ContextLoader} SPI,
 * {@link #processContextConfiguration(ContextConfigurationAttributes)} delegates
 * to {@link #processLocations(Class, String...)}.
 *
 * @author Sam Brannen
 * @author Juergen Hoeller
 * @author Phillip Webb
 * @see #generateDefaultLocations
 * @see #getResourceSuffixes
 * @see #modifyLocations
 * @see #prepareContext
 * @see #customizeContext
 * @since 2.5
 */
public abstract class AbstractContextLoader implements SmartContextLoader {

    private static final String[] EMPTY_STRING_ARRAY = new String[0];

    private static final Log logger = LogFactory.getLog(AbstractContextLoader.class);


    // SmartContextLoader

    /**
     * For backwards compatibility with the {@link ContextLoader} SPI, the
     * default implementation simply delegates to {@link #processLocations(Class, String...)},
     * passing it the {@link ContextConfigurationAttributes#getDeclaringClass()
     * declaring class} and {@link ContextConfigurationAttributes#getLocations()
     * resource locations} retrieved from the supplied
     * {@link ContextConfigurationAttributes configuration attributes}. The
     * processed locations are then
     * {@link ContextConfigurationAttributes#setLocations(String[]) set} in
     * the supplied configuration attributes.
     * <p>Can be overridden in subclasses &mdash; for example, to process
     * annotated classes instead of resource locations.
     *
     * @see #processLocations(Class, String...)
     * @since 3.1
     */
    @Override
    public void processContextConfiguration(ContextConfigurationAttributes configAttributes) {
        String[] processedLocations =
                processLocations(configAttributes.getDeclaringClass(), configAttributes.getLocations());
        configAttributes.setLocations(processedLocations);
    }

    /**
     * Prepare the {@link ConfigurableApplicationContext} created by this
     * {@code SmartContextLoader} <i>before</i> bean definitions are read.
     * <p>The default implementation:
     * <ul>
     * <li>Sets the <em>active bean definition profiles</em> from the supplied
     * {@code MergedContextConfiguration} in the
     * {@link org.springframework.core.env.Environment Environment} of the
     * context.</li>
     * <li>Adds {@link PropertySource PropertySources} for all
     * {@linkplain MergedContextConfiguration#getPropertySourceLocations()
     * resource locations} and
     * {@linkplain MergedContextConfiguration#getPropertySourceProperties()
     * inlined properties} from the supplied {@code MergedContextConfiguration}
     * to the {@code Environment} of the context.</li>
     * <li>Determines what (if any) context initializer classes have been supplied
     * via the {@code MergedContextConfiguration} and instantiates and
     * {@linkplain ApplicationContextInitializer#initialize invokes} each with the
     * given application context.
     * <ul>
     * <li>Any {@code ApplicationContextInitializers} implementing
     * {@link org.springframework.core.Ordered Ordered} or annotated with {@link
     * org.springframework.core.annotation.Order @Order} will be sorted appropriately.</li>
     * </ul>
     * </li>
     * </ul>
     *
     * @param context      the newly created application context
     * @param mergedConfig the merged context configuration
     * @see TestPropertySourceUtils#addPropertiesFilesToEnvironment
     * @see TestPropertySourceUtils#addInlinedPropertiesToEnvironment
     * @see ApplicationContextInitializer#initialize(ConfigurableApplicationContext)
     * @see #loadContext(MergedContextConfiguration)
     * @see ConfigurableApplicationContext#setId
     * @since 3.2
     */
    protected void prepareContext(ConfigurableApplicationContext context, MergedContextConfiguration mergedConfig) {
        context.getEnvironment().setActiveProfiles(mergedConfig.getActiveProfiles());
        TestPropertySourceUtils.addPropertiesFilesToEnvironment(context, mergedConfig.getPropertySourceLocations());
        TestPropertySourceUtils.addInlinedPropertiesToEnvironment(context, mergedConfig.getPropertySourceProperties());
        invokeApplicationContextInitializers(context, mergedConfig);
    }

    @SuppressWarnings("unchecked")
    private void invokeApplicationContextInitializers(ConfigurableApplicationContext context,
                                                      MergedContextConfiguration mergedConfig) {

        Set<Class<? extends ApplicationContextInitializer<?>>> initializerClasses =
                mergedConfig.getContextInitializerClasses();
        if (initializerClasses.isEmpty()) {
            // no ApplicationContextInitializers have been declared -> nothing to do
            return;
        }

        List<ApplicationContextInitializer<ConfigurableApplicationContext>> initializerInstances = new ArrayList<>();
        Class<?> contextClass = context.getClass();

        for (Class<? extends ApplicationContextInitializer<?>> initializerClass : initializerClasses) {
            Class<?> initializerContextClass =
                    GenericTypeResolver.resolveTypeArgument(initializerClass, ApplicationContextInitializer.class);
            if (initializerContextClass != null && !initializerContextClass.isInstance(context)) {
                throw new ApplicationContextException(String.format(
                        "Could not apply context initializer [%s] since its generic parameter [%s] " +
                                "is not assignable from the type of application context used by this " +
                                "context loader: [%s]", initializerClass.getName(), initializerContextClass.getName(),
                        contextClass.getName()));
            }
            initializerInstances.add((ApplicationContextInitializer<ConfigurableApplicationContext>) BeanUtils.instantiateClass(initializerClass));
        }

        AnnotationAwareOrderComparator.sort(initializerInstances);
        for (ApplicationContextInitializer<ConfigurableApplicationContext> initializer : initializerInstances) {
            initializer.initialize(context);
        }
    }

    /**
     * Customize the {@link ConfigurableApplicationContext} created by this
     * {@code ContextLoader} <em>after</em> bean definitions have been loaded
     * into the context but <em>before</em> the context has been refreshed.
     * <p>The default implementation delegates to all
     * {@link MergedContextConfiguration#getContextCustomizers context customizers}
     * that have been registered with the supplied {@code mergedConfig}.
     *
     * @param context      the newly created application context
     * @param mergedConfig the merged context configuration
     * @since 4.3
     */
    protected void customizeContext(ConfigurableApplicationContext context, MergedContextConfiguration mergedConfig) {
        for (ContextCustomizer contextCustomizer : mergedConfig.getContextCustomizers()) {
            contextCustomizer.customizeContext(context, mergedConfig);
        }
    }


    // ContextLoader

    /**
     * If the supplied {@code locations} are {@code null} or <em>empty</em>
     * and {@link #isGenerateDefaultLocations()} returns {@code true},
     * default locations will be {@link #generateDefaultLocations(Class)
     * generated} (i.e., detected) for the specified {@link Class class}
     * and the configured {@linkplain #getResourceSuffixes() resource suffixes};
     * otherwise, the supplied {@code locations} will be
     * {@linkplain #modifyLocations modified} if necessary and returned.
     *
     * @param clazz     the class with which the locations are associated: to be
     *                  used when generating default locations
     * @param locations the unmodified locations to use for loading the
     *                  application context (can be {@code null} or empty)
     * @return a processed array of application context resource locations
     * @see #isGenerateDefaultLocations()
     * @see #generateDefaultLocations(Class)
     * @see #modifyLocations(Class, String...)
     * @see org.springframework.test.context.ContextLoader#processLocations(Class, String...)
     * @see #processContextConfiguration(ContextConfigurationAttributes)
     * @since 2.5
     */
    @Override
    public final String[] processLocations(Class<?> clazz, String... locations) {
        return (ObjectUtils.isEmpty(locations) && isGenerateDefaultLocations()) ?
                generateDefaultLocations(clazz) : modifyLocations(clazz, locations);
    }

    /**
     * Generate the default classpath resource locations array based on the
     * supplied class.
     * <p>For example, if the supplied class is {@code com.example.MyTest},
     * the generated locations will contain a single string with a value of
     * {@code "classpath:com/example/MyTest<suffix>"}, where {@code <suffix>}
     * is the value of the first configured
     * {@linkplain #getResourceSuffixes() resource suffix} for which the
     * generated location actually exists in the classpath.
     * <p>As of Spring 3.1, the implementation of this method adheres to the
     * contract defined in the {@link SmartContextLoader} SPI. Specifically,
     * this method will <em>preemptively</em> verify that the generated default
     * location actually exists. If it does not exist, this method will log a
     * warning and return an empty array.
     * <p>Subclasses can override this method to implement a different
     * <em>default location generation</em> strategy.
     *
     * @param clazz the class for which the default locations are to be generated
     * @return an array of default application context resource locations
     * @see #getResourceSuffixes()
     * @since 2.5
     */
    protected String[] generateDefaultLocations(Class<?> clazz) {
        Assert.notNull(clazz, "Class must not be null");

        String[] suffixes = getResourceSuffixes();
        for (String suffix : suffixes) {
            Assert.hasText(suffix, "Resource suffix must not be empty");
            String resourcePath = ClassUtils.convertClassNameToResourcePath(clazz.getName()) + suffix;
            String prefixedResourcePath = ResourceUtils.CLASSPATH_URL_PREFIX + resourcePath;
            ClassPathResource classPathResource = new ClassPathResource(resourcePath);
            if (classPathResource.exists()) {
                if (logger.isInfoEnabled()) {
                    logger.info(String.format("Detected default resource location \"%s\" for test class [%s]",
                            prefixedResourcePath, clazz.getName()));
                }
                return new String[]{prefixedResourcePath};
            }
            else if (logger.isDebugEnabled()) {
                logger.debug(String.format("Did not detect default resource location for test class [%s]: " +
                        "%s does not exist", clazz.getName(), classPathResource));
            }
        }

        if (logger.isInfoEnabled()) {
            logger.info(String.format("Could not detect default resource locations for test class [%s]: " +
                    "no resource found for suffixes %s.", clazz.getName(), ObjectUtils.nullSafeToString(suffixes)));
        }

        return EMPTY_STRING_ARRAY;
    }

    /**
     * Generate a modified version of the supplied locations array and return it.
     * <p>The default implementation simply delegates to
     * {@link TestContextResourceUtils#convertToClasspathResourcePaths}.
     * <p>Subclasses can override this method to implement a different
     * <em>location modification</em> strategy.
     *
     * @param clazz     the class with which the locations are associated
     * @param locations the resource locations to be modified
     * @return an array of modified application context resource locations
     * @since 2.5
     */
    protected String[] modifyLocations(Class<?> clazz, String... locations) {
        return TestContextResourceUtils.convertToClasspathResourcePaths(clazz, locations);
    }

    /**
     * Determine whether or not <em>default</em> resource locations should be
     * generated if the {@code locations} provided to
     * {@link #processLocations(Class, String...)} are {@code null} or empty.
     * <p>As of Spring 3.1, the semantics of this method have been overloaded
     * to include detection of either default resource locations or default
     * configuration classes. Consequently, this method can also be used to
     * determine whether or not <em>default</em> configuration classes should be
     * detected if the {@code classes} present in the
     * {@link ContextConfigurationAttributes configuration attributes} supplied
     * to {@link #processContextConfiguration(ContextConfigurationAttributes)}
     * are {@code null} or empty.
     * <p>Can be overridden by subclasses to change the default behavior.
     *
     * @return always {@code true} by default
     * @since 2.5
     */
    protected boolean isGenerateDefaultLocations() {
        return true;
    }

    /**
     * Get the suffixes to append to {@link ApplicationContext} resource locations
     * when detecting default locations.
     * <p>The default implementation simply wraps the value returned by
     * {@link #getResourceSuffix()} in a single-element array, but this
     * can be overridden by subclasses in order to support multiple suffixes.
     *
     * @return the resource suffixes; never {@code null} or empty
     * @see #generateDefaultLocations(Class)
     * @since 4.1
     */
    protected String[] getResourceSuffixes() {
        return new String[]{getResourceSuffix()};
    }

    /**
     * Get the suffix to append to {@link ApplicationContext} resource locations
     * when detecting default locations.
     * <p>Subclasses must provide an implementation of this method that returns
     * a single suffix. Alternatively subclasses may provide a  <em>no-op</em>
     * implementation of this method and override {@link #getResourceSuffixes()}
     * in order to provide multiple custom suffixes.
     *
     * @return the resource suffix; never {@code null} or empty
     * @see #generateDefaultLocations(Class)
     * @see #getResourceSuffixes()
     * @since 2.5
     */
    protected abstract String getResourceSuffix();

}
